#include "QueueOperation.h"
#include "Tools.h"

const bool CQueueOperation::IsQueueExist(const char * pszQueueName)
{
    return ValueSet().ExistValue(pszQueueName);
}

bool CQueueOperation::CreateQueue(const char * pszQueueName, int iQueueType /*= 1*/)
{		
	IQueue * ptrQueue = Queue(pszQueueName);	
	bool bCreateFlg = (ptrQueue) && (ptrQueue->QueueType() == iQueueType);
	if (!bCreateFlg)
	{
		string strCls(iQueueType == 1 ? "CQueue" : "CShrMemQueue");
		IObject * ptrRetVal = Instance<IObject>(strCls.c_str(), (void *)pszQueueName, nullptr, 0);
		bCreateFlg = ValueSet().SetValue(pszQueueName, ptrRetVal);
	}
    return bCreateFlg;
}

bool CQueueOperation::FreeQueue(const char * pszQueueName)
{
	return ValueSet().DelVar(pszQueueName);
}

bool CQueueOperation::PushTask(const char * pszQueueName, const char * pszTask, int iQueueKey /*= -1*/)
{
    bool bRetVal = false;
    IData * ptrData = nullptr;
    if (FrameTools().StrFun().IsEmpty(pszTask))
    {
        goto __end;
    }
    ptrData = Instance<IData>("CData", reinterpret_cast<const void *>(pszTask), nullptr, 0);
    if (ptrData == nullptr)
    {
        goto __end;
    }
	bRetVal = PushTask(pszQueueName, ptrData, iQueueKey);
__end:
    return bRetVal;
}

bool CQueueOperation::PushTask(const char * pszQueueName, IData * ptrTask, int iQueueKey /*= -1*/)
{
    bool bRetVal = false;
	IQueue * ptrQueue = Queue(pszQueueName);
	if (!ptrQueue) goto  __end;
    bRetVal = ptrQueue->Push(ptrTask, iQueueKey);
__end:
    return bRetVal;
}

IData * CQueueOperation::PopTask(const char * pszQueueName)
{
    IData * ptrRetVal = nullptr;
	IQueue * ptrQueue = Queue(pszQueueName);
	if (!ptrQueue) goto  __end;
    if ((ptrRetVal = ptrQueue->Pop()) == nullptr) goto __end;
	if (ptrQueue->QueueType() == 1 &&
		ptrRetVal->GetQueueKey() >= 0 &&
		ptrRetVal->GetQueueKey() != ptrQueue->QueueKey())
	{
		delete ptrRetVal;
		ptrRetVal = nullptr;
	}
__end:
    return ptrRetVal;
}

int CQueueOperation::QueueKey(const char * pszQueueName)
{
	int iRetVal = -1;
	IQueue * ptrQueue = Queue(pszQueueName);
	if (!ptrQueue) goto  __end;
    iRetVal = ptrQueue->QueueKey();
__end:
	return iRetVal;
}

bool CQueueOperation::EmptyQueue(const char * pszQueueName)
{
    bool bRetVal = false;
	auto ClearQueue = [&](const char * pszName)->bool
	{
		IQueue * ptrQueue = Queue(pszName);
		if (!ptrQueue) return false;
		bRetVal = ptrQueue->EmptyQueue();
	};
	if (FrameTools().StrFun().IsEmpty(pszQueueName))
	{
		vector<string> vtNameList;
		if (ValueSet().GetValNameList(reinterpret_cast<void *>(&vtNameList)))
			for (auto it : vtNameList)
				ClearQueue(it.c_str());
	}
	else ClearQueue(pszQueueName);
__end:
    return bRetVal;
}

bool CQueueOperation::FlipQueueKey(const char * pszQueueName)
{
	bool bRetVal = false;
	IQueue * ptrQueue = Queue(pszQueueName);
	if (!ptrQueue) goto  __end;
	bRetVal = ptrQueue->FlipQueueKey();
__end:
	return bRetVal;
}

IQueue * CQueueOperation::Queue(const char * pszName)
{
	IBaseObject * ptrRetVal = nullptr;
	IQueue * ptrQueue = nullptr;
	if (ValueSet().GetValue(pszName, &ptrRetVal)) ptrQueue = dynamic_cast<IQueue *>(ptrRetVal);
__end:
	return ptrQueue;
}

